Reviewing Core Python Concepts and Common Programming Questions

Course: Python Training

Topic: Reviewing Core Python Concepts and Common Programming Questions

Course Link: Python Training Course – JustAcademy

Demo Link: Register for a Course Demo

Website: Visit JustAcademy

1. Introduction to Core Python Revision

Reviewing core Python concepts helps learners strengthen their programming fundamentals, improve problem-solving skills, and prepare for coding assessments, technical interviews, and practical projects. Core Python includes variables, data types, operators, conditional statements, loops, functions, collections, object-oriented programming, exception handling, file operations, modules, and commonly used built-in functions.

A structured revision process should focus on understanding concepts, writing small programs, explaining the logic behind solutions, and recognizing common programming mistakes. Instead of memorizing answers, learners should practice adapting their knowledge to new problems.

Learning Objectives

• Revise Python syntax, variables, data types, and operators.
• Understand conditional statements, loops, and control flow.
• Practice working with strings, lists, tuples, sets, and dictionaries.
• Review functions, arguments, scope, and return values.
• Understand object-oriented programming fundamentals.
• Review exceptions, file handling, modules, and common built-in functions.
• Solve frequently asked Python programming questions.
• Improve code readability, debugging, testing, and interview communication.

2. Python Variables and Data Types

A variable is a name that refers to an object in memory. Python is dynamically typed, meaning a variable does not need an explicit type declaration before assignment. The type of the object can be inspected using the type() function.

Common Built-in Data Types

Example: Inspecting Data Types

name = "Aarav"
age = 25
salary = 35000.75
is_employee = True

print(type(name))
print(type(age))
print(type(salary))
print(type(is_employee))

Important Concepts

• Dynamic typing: Variable names can refer to objects of different types at different times.
• Type conversion: Functions such as int(), float(), and str() convert compatible values.
• Mutability: Lists and dictionaries can be modified after creation, whereas strings and tuples are immutable.
• Identity and equality: == compares values, while is checks object identity.

3. Operators in Python

Operators perform calculations, comparisons, logical evaluations, membership checks, and other operations on values.

Example

a = 17
b = 5

print(a + b)   # 22
print(a // b)  # 3
print(a % b)   # 2
print(a ** 2)  # 289
print(a > b)   # True
print(a % 2 == 0)  # False

Interview tip: Understand the difference between / and //. Division using / returns a floating-point result, while // performs floor division. For negative numbers, floor division rounds down toward negative infinity.

4. Conditional Statements and Control Flow

Conditional statements execute different blocks of code depending on whether a condition evaluates to true or false.

Using if, elif, and else

marks = 78

if marks >= 90:
    grade = "A"
elif marks >= 75:
    grade = "B"
elif marks >= 60:
    grade = "C"
else:
    grade = "Needs Improvement"

print(grade)

Nested Conditions and Truthiness

Python treats some values as false in conditional contexts, including False, None, numeric zero, and empty collections. Most other objects are truthy.

username = ""

if username:
    print("Username provided")
else:
    print("Username is empty")

Best Practices

• Use clear conditions and meaningful variable names.
• Keep nested conditions as simple as possible.
• Use elif when multiple mutually exclusive conditions must be checked.
• Validate user input before relying on it in business logic.

5. Loops and Iteration

Loops repeat a block of code. Python provides for loops for iterating over iterables and while loops for repeating while a condition remains true.

For Loop

for number in range(1, 6):
    print(number)

While Loop

count = 1

while count <= 5:
    print(count)
    count += 1

break, continue, and pass

• break exits the nearest enclosing loop.
• continue skips the remainder of the current iteration.
• pass is a placeholder statement that performs no operation.

Example: Sum of Numbers

numbers = [10, 20, 30, 40]
total = 0

for number in numbers:
    total += number

print("Total:", total)

Expected output: Total: 100

When solving loop questions, check the initial value, termination condition, update step, and behavior for empty input. These details help prevent infinite loops and off-by-one errors.

6. Strings and Common String Operations

A string is an immutable sequence of Unicode characters. Strings support indexing, slicing, iteration, formatting, and many useful methods.

Frequently Used String Methods

Common Programming Question: Check a Palindrome

A palindrome reads the same forward and backward, such as level or madam.

def is_palindrome(text):
    cleaned = text.casefold()
    return cleaned == cleaned[::-1]

print(is_palindrome("Level"))
print(is_palindrome("Python"))

Output: True, then False.

This example ignores letter case but does not remove spaces or punctuation. If a question expects phrases such as “Never odd or even” to count as palindromes, normalize the text by removing non-alphanumeric characters first.

7. Lists, Tuples, Sets, and Dictionaries

Python's built-in collections store and organize groups of values. Selecting the correct collection makes programs clearer and can improve performance.

List Operations

numbers = [10, 20, 30]
numbers.append(40)
numbers.remove(20)

print(numbers)
print(numbers[0])
print(numbers[-1])

Tuple Example

coordinates = (12.5, 18.2)
x, y = coordinates

print(x)
print(y)

Set Operations

first = {1, 2, 3, 4}
second = {3, 4, 5, 6}

print(first | second)  # Union
print(first & second)  # Intersection
print(first - second)  # Difference

Dictionary Example

student = {
    "name": "Aarav",
    "marks": 88
}

student["grade"] = "A"
print(student["name"])
print(student.get("age", "Not provided"))

Use dict.get() when a missing key should return a default value rather than raise a KeyError. Use square-bracket access when a missing key should be treated as an error.

8. Functions, Parameters, and Return Values

A function is a reusable block of code defined with the def keyword. Functions can accept inputs, process them, and return results.

def calculate_total(price, quantity=1):
    return price * quantity

print(calculate_total(100, 3))
print(calculate_total(100))

Output: 300 and 100.

Types of Function Arguments

• Positional arguments: Values are assigned according to parameter position.
• Keyword arguments: Values are passed using parameter names.
• Default arguments: Parameters have predefined values.
• Variable positional arguments: *args collects extra positional arguments into a tuple.
• Variable keyword arguments: **kwargs collects extra keyword arguments into a dictionary.

Example: Using *args and **kwargs

def show_details(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)

show_details("Python", "Beginner", level=1, active=True)

Return Versus Print

print() displays information, whereas return sends a result back to the caller. A function without an explicit return statement returns None.

def add(a, b):
    return a + b

result = add(5, 7)
print(result)

Common Mistake: Mutable Default Arguments

A mutable default argument is created once when the function is defined, not each time the function is called. Use None when a fresh collection is needed for each call.

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("book"))
print(add_item("pen"))

9. List Comprehensions and Useful Built-in Functions

List comprehensions provide a concise way to create lists from iterables. They can include conditions to filter values.

squares = [number ** 2 for number in range(1, 6)]
even_numbers = [number for number in range(1, 11) if number % 2 == 0]

print(squares)
print(even_numbers)

Frequently Used Built-ins

Example: enumerate() and zip()

names = ["Aarav", "Meera", "Kabir"]

for index, name in enumerate(names, start=1):
    print(index, name)

subjects = ["Python", "SQL"]
scores = [90, 85]

for subject, score in zip(subjects, scores):
    print(subject, score)

Comprehensions are useful for simple transformations. For complicated logic, prefer a regular loop or a separate function to keep the code readable.

10. Object-Oriented Programming Fundamentals

Object-oriented programming (OOP) organizes code around classes and objects. A class defines attributes and methods, while an object is an instance of that class.

Core OOP Concepts

• Class: A blueprint describing data and behavior.
• Object: An instance created from a class.
• Encapsulation: Organizing data and methods together and controlling access through a clear interface.
• Inheritance: Creating a class that reuses or extends behavior from another class.
• Polymorphism: Using a common interface with different implementations.
• Abstraction: Exposing essential behavior while hiding unnecessary implementation details.

Example: Class and Object

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    def display(self):
        return f"{self.name} scored {self.marks}"

student = Student("Meera", 92)
print(student.display())

The __init__() method initializes a new instance. The parameter self refers to the current instance and is used to access its attributes and methods.

Example: Inheritance

class Animal:
    def speak(self):
        return "Animal sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

dog = Dog()
print(dog.speak())

The Dog class inherits from Animal and overrides its speak() method. This illustrates inheritance and method overriding.

11. Scope, Namespaces, and Lambda Functions

Scope determines where a name can be accessed. Python commonly follows the LEGB lookup order: Local, Enclosing, Global, and Built-in.

message = "Global"

def display():
    message = "Local"
    print(message)

display()
print(message)

The function prints Local, while the statement outside the function prints Global. Assignments inside a function normally create local names unless global or nonlocal is used.

Lambda Functions

A lambda is a small anonymous function consisting of a single expression.

square = lambda number: number ** 2
print(square(6))

Use a normal def function when logic needs multiple statements, documentation, or a meaningful reusable name.

12. Iterators, Generators, and the yield Keyword

An iterable is an object that can provide its elements one at a time, such as a list or string. An iterator maintains iteration state and returns values through next(). A generator is a convenient way to create an iterator using a function and the yield keyword.

Generator Example

def count_up_to(limit):
    number = 1
    while number <= limit:
        yield number
        number += 1

for value in count_up_to(3):
    print(value)

Generators produce values lazily, which can reduce memory use when processing large sequences. A generator is generally consumed as it is iterated and is not automatically reusable from the beginning.

13. Exception Handling

Exceptions are runtime events that interrupt normal execution. Python provides try, except, else, and finally to handle errors and clean up resources.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return "Cannot divide by zero"
    else:
        return result
    finally:
        print("Division operation completed")

print(divide(10, 2))
print(divide(10, 0))

Exception-Handling Guidelines

• Catch specific exceptions instead of using a broad except: clause.
• Use finally for cleanup that must occur regardless of success or failure.
• Use else for code that should run only when the try block succeeds.
• Raise meaningful exceptions when a function cannot satisfy its contract.
• Do not silently suppress errors that should be investigated.

14. File Handling and Context Managers

File handling allows programs to read and write persistent data. The open() function supports different modes, including reading, writing, appending, and binary operations.

Example: Writing and Reading a File

with open("notes.txt", "w", encoding="utf-8") as file:
    file.write("Core Python revision")

with open("notes.txt", "r", encoding="utf-8") as file:
    content = file.read()

print(content)

The with statement uses a context manager so the file is properly closed after the block, including when an exception occurs.

15. Modules, Packages, and Imports

A module is a Python file containing reusable code. A package groups related modules into a directory structure. Imports allow a program to reuse functions, classes, and variables defined elsewhere.

import math
from pathlib import Path

print(math.sqrt(81))
print(Path("notes.txt").suffix)

Why Use Modules?

• Separate responsibilities into manageable files.
• Reuse common functions without duplicating code.
• Improve testing and maintainability.
• Organize large applications by feature or purpose.

For scripts that should run directly while remaining importable, a common entry-point pattern is:

def main():
    print("Python application started")

if __name__ == "__main__":
    main()

This condition executes main() when the file is run as a script, but not merely because it is imported as a module.

16. Common Python Programming Questions

Question 1: Swap Two Variables

a = 10
b = 20

a, b = b, a

print(a, b)

Explanation: Python supports multiple assignment and unpacking, so a temporary variable is not necessary.

Question 2: Find the Largest Number in a List

def find_largest(numbers):
    if not numbers:
        raise ValueError("The list must not be empty")
    return max(numbers)

print(find_largest([12, 45, 7, 31]))

Explanation: The built-in max() function returns the largest item. The function explicitly handles an empty list.

Question 3: Check Whether a Number Is Even or Odd

def even_or_odd(number):
    if number % 2 == 0:
        return "Even"
    return "Odd"

print(even_or_odd(14))
print(even_or_odd(9))

Explanation: The remainder operator % returns zero when an integer is evenly divisible by two.

Question 4: Calculate Factorial

The factorial of a non-negative integer \(n\) is the product of all positive integers up to \(n\), with \(0! = 1\).

def factorial(number):
    if number < 0:
        raise ValueError("Factorial is undefined for negative integers")

    result = 1
    for value in range(2, number + 1):
        result *= value

    return result

print(factorial(5))

Output: 120.

Question 5: Generate the Fibonacci Sequence

def fibonacci(count):
    if count < 0:
        raise ValueError("Count cannot be negative")

    sequence = []
    a, b = 0, 1

    for _ in range(count):
        sequence.append(a)
        a, b = b, a + b

    return sequence

print(fibonacci(7))

Output: [0, 1, 1, 2, 3, 5, 8].

Question 6: Count Vowels in a String

def count_vowels(text):
    vowels = "aeiou"
    return sum(1 for char in text.casefold() if char in vowels)

print(count_vowels("Python Programming"))

Explanation: The generator expression produces one for every vowel found, and sum() adds the results.

Question 7: Remove Duplicates from a List

def remove_duplicates(items):
    return list(dict.fromkeys(items))

print(remove_duplicates([1, 2, 2, 3, 1, 4]))

Output: [1, 2, 3, 4].

Explanation: Dictionaries preserve insertion order in modern Python, so this approach retains the first occurrence of each hashable item.

Question 8: Count Character Frequencies

def character_frequency(text):
    frequency = {}

    for char in text:
        frequency[char] = frequency.get(char, 0) + 1

    return frequency

print(character_frequency("hello"))

Explanation: A dictionary stores each character as a key and its occurrence count as the value.

Question 9: Check Whether a Number Is Prime

def is_prime(number):
    if number < 2:
        return False

    divisor = 2
    while divisor * divisor <= number:
        if number % divisor == 0:
            return False
        divisor += 1

    return True

print(is_prime(17))
print(is_prime(18))

Explanation: It is sufficient to test divisors up to the square root of the number. The loop condition avoids calculating a square root explicitly.

Question 10: Find Common Elements in Two Lists

def common_elements(first, second):
    second_values = set(second)
    return list(dict.fromkeys(
        item for item in first if item in second_values
    ))

print(common_elements([1, 2, 3, 2], [2, 3, 4]))

Output: [2, 3].

Explanation: Converting the second collection to a set makes membership checks efficient on average. The dictionary-based step preserves the first list's order and removes repeated matches.

17. Frequently Asked Python Interview Questions

Q1. What is Python?

Python is a high-level, general-purpose programming language known for readable syntax and a broad ecosystem of libraries. It is used in web development, automation, data analysis, testing, scripting, and many other fields.

Q2. Is Python compiled or interpreted?

Python implementations vary. In the common CPython implementation, source code is compiled into bytecode and then executed by the Python virtual machine. Calling Python simply “interpreted” is a useful simplification, but it does not describe every implementation detail.

Q3. What is the difference between a list and a tuple?

A list is mutable, meaning its elements can be added, removed, or replaced. A tuple is immutable after creation. Lists are suitable for changing collections, while tuples are useful for fixed groups of values.

Q4. What is the difference between == and is?

== checks whether two objects compare equal in value. is checks whether two references point to the same object. Use is None to check whether a value is None.

Q5. What is the difference between append() and extend()?

append() adds its argument as one item. extend() adds each element from an iterable to the list.

numbers = [1, 2]
numbers.append([3, 4])
print(numbers)  # [1, 2, [3, 4]]

numbers = [1, 2]
numbers.extend([3, 4])
print(numbers)  # [1, 2, 3, 4]

Q6. What is the difference between shallow copy and deep copy?

A shallow copy creates a new outer collection but keeps references to nested objects. A deep copy recursively copies nested objects where supported. The copy module provides copy() and deepcopy().

Q7. What are *args and **kwargs?

*args collects extra positional arguments into a tuple, and **kwargs collects extra keyword arguments into a dictionary.

Q8. What is PEP 8?

PEP 8 is the widely used style guide for Python code. It provides recommendations for indentation, naming, line length, imports, whitespace, and other conventions that help maintain consistency.

Q9. What is a decorator?

A decorator is a callable that takes another callable and returns a callable, commonly adding behavior without changing the original function's main implementation.

def announce(func):
    def wrapper():
        print("Starting")
        result = func()
        print("Finished")
        return result
    return wrapper

@announce
def greet():
    print("Hello")

greet()

In production code, functools.wraps is commonly used inside decorators to preserve useful metadata from the wrapped function.

Q10. What is a virtual environment?

A virtual environment isolates a project's Python packages from other projects. This helps prevent dependency conflicts and supports repeatable development setups.

python -m venv .venv

Activate the environment using the command appropriate for the operating system, then install dependencies using python -m pip install package_name.

Q11. What is the difference between a syntax error and an exception?

A syntax error occurs when Python cannot parse the code according to its grammar. An exception occurs during execution or is raised by code when an operation cannot proceed normally.

Q12. What is recursion?

Recursion occurs when a function calls itself to solve a smaller version of a problem. A correct recursive solution needs a base case and progress toward that case. Deep recursion can exceed Python's recursion limit, so iteration may be more appropriate for some problems.

18. Time Complexity and Basic Problem-Solving Skills

Time complexity describes how an algorithm's running time grows as input size increases. Space complexity describes how its memory requirements grow. Big O notation expresses an upper-bound growth rate while abstracting away many machine-specific details.

Example: Linear Search

def find_index(items, target):
    for index, item in enumerate(items):
        if item == target:
            return index
    return -1

print(find_index([10, 20, 30, 40], 30))

This algorithm has O(n) worst-case time complexity because it may inspect every element. Its auxiliary space complexity is O(1), excluding the input and returned result.

Steps for Solving Coding Questions

1. Read the problem carefully and identify the required output.
2. Clarify input types, constraints, and edge cases.
3. Work through a small example manually.
4. Choose a suitable algorithm and data structure.
5. Write a clear solution with meaningful names.
6. Test normal, boundary, empty, and invalid inputs where relevant.
7. Evaluate time and space complexity.
8. Explain why the solution works and what trade-offs it makes.

19. Debugging, Testing, and Code Quality

Correctness is not established merely because a program works for one example. Testing should cover typical use cases, edge cases, and error conditions. Debugging helps locate the source of unexpected behavior.

Simple Assertions

def square(number):
    return number * number

assert square(3) == 9
assert square(0) == 0
assert square(-2) == 4

Assertions are useful for development checks, but they can be disabled when Python runs with optimization. Do not use assertions as the only validation for external input or security-critical conditions.

Basic Unit Testing with unittest

import unittest

def add(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def test_positive_numbers(self):
        self.assertEqual(add(2, 3), 5)

    def test_negative_number(self):
        self.assertEqual(add(-2, 1), -1)

if __name__ == "__main__":
    unittest.main()

Common Programming Mistakes

• Using = where a comparison is needed, or confusing == and is.
• Forgetting that list indexes start at zero.
• Writing loop conditions that never become false.
• Modifying a list while iterating over it without considering the consequences.
• Assuming a dictionary key exists without checking it or handling KeyError.
• Using mutable default function arguments unintentionally.
• Ignoring exceptions or catching overly broad exception types.
• Forgetting to close files when not using a context manager.
• Writing code that handles only the sample input rather than general cases.

20. Practical Revision Exercises

Complete the following exercises without immediately checking a solution. Explain your approach, test your code, and review its complexity.

1. Write a program that checks whether a number is positive, negative, or zero.
2. Write a function that reverses a string without using a built-in reverse method.
3. Count the number of words in a sentence.
4. Find the second-largest distinct number in a list.
5. Remove duplicates from a list while preserving the original order.
6. Merge two dictionaries and define how duplicate keys should be handled.
7. Write a function that checks whether two strings are anagrams.
8. Calculate the sum of all even numbers in a list.
9. Read a text file and count its lines, words, and characters.
10. Create a class representing a bank account with deposit and withdrawal methods.
11. Handle invalid numeric input using exception handling.
12. Write unit tests for a function that calculates a factorial.

Mini Project: Student Result Manager

Build a small command-line application that manages student names, marks, grades, and result summaries. The project combines several core Python concepts in one practical task.

Project Requirements

• Accept student names and marks from user input.
• Validate that marks are within an agreed range, such as 0 to 100.
• Store student records using dictionaries or a list of dictionaries.
• Calculate total marks, average marks, and grades.
• Search for a student by name.
• Display the student with the highest marks.
• Handle invalid input gracefully.
• Save and load records using a JSON file.
• Write unit tests for calculation and validation functions.
• Document how to run the program and include example output.

Suggested Project Structure

student_result_manager/
    main.py
    student.py
    storage.py
    tests/
        test_student.py
    README.md

Keep user interaction, calculations, and file storage in separate functions or modules. This makes the application easier to understand, test, and extend.

21. Interview Preparation Strategy

When preparing for a Python technical interview, focus on explaining concepts and demonstrating practical problem-solving rather than memorizing definitions alone.

• Concept revision: Explain variables, mutability, collections, functions, exceptions, and OOP in your own words.
• Coding practice: Solve string, list, dictionary, number, and basic algorithm questions.
• Edge cases: Consider empty collections, duplicate values, negative numbers, and invalid input.
• Complexity analysis: Identify the time and auxiliary space complexity of your solution.
• Code quality: Use descriptive names, small functions, clear control flow, and appropriate error handling.
• Testing: Demonstrate how you verify the expected result and handle unexpected cases.
• Communication: Explain assumptions, approach, implementation, and trade-offs clearly.
• Project discussion: Be ready to describe your project structure, key decisions, bugs, testing, and improvements.

22. Quick Revision Checklist

• Understand Python variables, built-in data types, and type conversion.
• Know arithmetic, comparison, logical, membership, and identity operators.
• Write conditional statements and loops correctly.
• Use string methods, slicing, and formatting.
• Understand when to choose lists, tuples, sets, and dictionaries.
• Define functions using positional, keyword, default, and variable arguments.
• Explain return values, variable scope, and mutable default arguments.
• Use comprehensions and common built-in functions appropriately.
• Understand classes, objects, inheritance, and polymorphism.
• Know iterators, generators, and the purpose of yield.
• Handle exceptions with specific exception types.
• Read and write files using context managers.
• Organize code into modules and packages.
• Solve common coding questions and explain the logic.
• Test edge cases and analyze basic time and space complexity.
• Maintain readable, documented, and testable code.

23. Conclusion

Reviewing core Python concepts provides a strong foundation for solving programming problems, building applications, and preparing for technical interviews. Consistent practice with variables, collections, functions, OOP, exception handling, file operations, and common coding questions helps learners move from basic syntax knowledge to confident problem-solving.

For best results, write code regularly, test different inputs, explain your reasoning, and build small projects that combine multiple concepts. Revisit difficult topics, review mistakes, and improve solutions for readability and efficiency.

Explore the Python Training Course, register for a course demo, or visit the JustAcademy website for more information.